﻿using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Windows.Forms;

public class Ctrl_Adjuntos2
{
   //'
   #region "Clase ArchivoAdjunto"

   private class clsArchivoAdjunto
   {
      private string strNombreArchivo;
      private string strNombreCompleto;
      private bool bolNuevo;
      /// <summary>
      /// Acciones (agregar o eliminar fichero) a realizar
      /// </summary>
      /// <remarks></remarks>
      public enum eAccionAdjunto
      {
         Agregar,
         Eliminar
      }
      //'
      public string NombreArchivo
      {
         get { return strNombreArchivo; }
         set { strNombreArchivo = value; }
      }

      public bool Nuevo
      {
         get { return bolNuevo; }
         set { bolNuevo = value; }
      }

      public string NombreCompleto
      {
         get { return strNombreCompleto; }
         set { strNombreCompleto = value; }
      }

      public override string ToString()
      {
         return strNombreArchivo;
      }
      //'
      #region "                                                                AccionAdjunto"
      private eAccionAdjunto p_AccionAdjunto;
      /// <summary>
      /// Acción a realizar con el adjunto (Agregar o eliminar)
      /// </summary>
      /// <value></value>
      /// <returns></returns>
      /// <remarks></remarks>
      public eAccionAdjunto AccionAdjunto
      {
         get { return p_AccionAdjunto; }
         set { p_AccionAdjunto = value; }
      }
      #endregion
      //'
   }
   #endregion
   //'
   #region "Variables privadas"
   //Private _colArchivosAdjuntos As New Collection
   //Private _colArchivosAdjuntosACopiar As New Collection
   //Private _colArchivosAdjuntosAEliminar As New Collection
   //Private _strRutaAdjuntosActual As String
   enum EAccion { Insercion, Modificacion }
   #region "                                                                CtrlContieneId"
   private Control p_CtrlContieneId;
   /// <summary>
   /// Cúal es el control que contiene el id de la carpeta? EJ: 1 -  Juan (1 es id)
   /// </summary>
   /// <value></value>
   /// <returns></returns>
   /// <remarks></remarks>
   public Control CtrlContieneId
   {
      get { return p_CtrlContieneId; }
      set { p_CtrlContieneId = value; }
   }
   #endregion
   #region "                                                                CtrlContieneDescripcion"
   private Control p_CtrlContieneDescripcion;
   /// <summary>
   /// Cúal es el control que contiene la descripcion de la carpeta?  EJ: 1 - Juan (Juan es descripción)
   /// </summary>
   /// <value></value>
   /// <returns></returns>
   /// <remarks></remarks>
   public Control CtrlContieneDescripcion
   {
      get { return p_CtrlContieneDescripcion; }
      set { p_CtrlContieneDescripcion = value; }
   }
   #endregion
   #region "                                                                strSubCarpetaindicada "
   private string p_strSubCarpetaindicada;
   /// <summary>
   /// Subcarpeta donde se guardan los adjuntos. EJ:  P:\Adhara\Adjuntos\agiKnowCliente\ (SubCarpeta es agiKnowCliente)
   /// </summary>
   /// <value></value>
   /// <returns></returns>
   /// <remarks></remarks>
   public string strSubCarpetaindicada
   {
      get { return p_strSubCarpetaindicada; }
      set { p_strSubCarpetaindicada = value; }
   }
   #endregion
   // Sustituye las collections por Acciones
   private System.Collections.Generic.Dictionary<string, clsArchivoAdjunto> _dicAccionesToDo = new System.Collections.Generic.Dictionary<string, clsArchivoAdjunto>();
   private string MensajeSegunIdioma;
   private string _strUbicacionRepositorio;
   private string m_IDActual;
   private string _strCarpeta;
   private string _strSubCarpeta;
   private System.Windows.Forms.ToolTip ToolTipGenerico;
   public enum eIdioma
   {
      Espanol,
      Catalan
   }
   //Enum eAccionFormPadre
   //   Agregar
   //   Eliminar
   //   Consulta
   //End Enum
   //#Region "                                                                AccionFormPadre"
   //   Private p_AccionFormPadre As eAccionFormPadre
   //   ''' <summary>
   //   ''' Accion del formulario padre....
   //   ''' </summary>
   //   ''' <value></value>
   //   ''' <returns></returns>
   //   ''' <remarks></remarks>
   //   Public Property AccionFormPadre() As eAccionFormPadre
   //      Get
   //         Return p_AccionFormPadre
   //      End Get
   //      Set(ByVal value As eAccionFormPadre)
   //         p_AccionFormPadre = value
   //      End Set
   //   End Property
   //#End Region
   #endregion
   private eIdioma p_Idioma = eIdioma.Catalan;
   //'
   #region "Constructor"
   public Ctrl_Adjuntos()
   {
      // This call is required by the Windows Form Designer.
      InitializeComponent();
      // Add any initialization after the InitializeComponent()  call.
      BorrarColeccionesDeDatos();
   }

   public void BorrarColeccionesDeDatos()
   {
      //_colArchivosAdjuntos.Clear()
      //_colArchivosAdjuntosACopiar.Clear()
      //_colArchivosAdjuntosAEliminar.Clear()
      _dicAccionesToDo.Clear();
      lstAdjuntos.Items.Clear();
   }
   #endregion
   //'
   #region "Propiedades públicas"
   public eIdioma Idioma
   {
      get { return p_Idioma; }
      set { p_Idioma = value; }
   }

   public string Carpeta
   {
      get { return _strCarpeta; }
      set { _strCarpeta = value; }
   }

   public string SubCarpeta
   {
      get { return _strSubCarpeta; }
      set { _strSubCarpeta = value; }
   }

   public string UbicacionRepositorio
   {
      get { return _strUbicacionRepositorio; }
      set
      {
         _strUbicacionRepositorio = value;
         if ((_strUbicacionRepositorio != null) && (_strUbicacionRepositorio == string.Empty || System.IO.Directory.Exists(_strUbicacionRepositorio) == false))
         {
            Enabled = false;
         }
      }
   }
   //'
   //Public ReadOnly Property ArchivosAdjuntos() As Collection
   //   Get
   //      Dim iteArchivo As Object
   //      _colArchivosAdjuntos.Clear()
   //      For Each iteArchivo In lstAdjuntos.Items
   //         _colArchivosAdjuntos.Add(iteArchivo)
   //      Next
   //      Return _colArchivosAdjuntos
   //   End Get
   //End Property
   // ''
   //Public Property ArchivosAdjuntosACopiar() As Collection
   //   Get
   //      Dim adjArchivo As clsArchivoAdjunto
   //      _colArchivosAdjuntosACopiar.Clear()
   //      For Each adjArchivo In lstAdjuntos.Items
   //         If adjArchivo.Nuevo Then
   //            _colArchivosAdjuntosACopiar.Add(adjArchivo)
   //         End If
   //      Next
   //      Return _colArchivosAdjuntosACopiar
   //   End Get
   //   Set(ByVal value As Collection)
   //      _colArchivosAdjuntosACopiar = value
   //   End Set
   //End Property

   //Public Property ArchivosAdjuntosAEliminar() As Collection
   //   Get
   //      Return _colArchivosAdjuntosAEliminar
   //   End Get
   //   Set(ByVal value As Collection)
   //      _colArchivosAdjuntosAEliminar = value
   //   End Set
   //End Property

   //'Public Property strRutaAdjuntosActual() As String
   //'   Get
   //'      Return _strRutaAdjuntosActual
   //'   End Get
   //'   Set(ByVal value As String)
   //'      _strRutaAdjuntosActual = value
   //'   End Set
   //'End Property
   //'
   public string IDActual
   {
      get { return m_IDActual; }
      set { m_IDActual = value; }
   }
   #endregion
   //'
   #region "Actualizar"
   #region " Obsoleto después Acciones"
   //Public Sub Actualizar()
   //   Dim di As System.IO.DirectoryInfo = Nothing

   //   Try
   //      If Not UbicacionRepositorio.Equals(String.Empty) AndAlso  Enabled Then
   //         Dim adjArchivo As clsArchivoAdjunto
   //         Dim diCarpeta As IO.DirectoryInfo
   //         Dim strUbicacionSecundaria As String =  UbicacionRepositorio & "\"

   //         If ArchivosAdjuntosACopiar.Count > 0 Then
   //            'Validar carpetas
   //            If Not Carpeta.Equals(String.Empty) Then
   //               strUbicacionSecundaria = strUbicacionSecundaria &  Carpeta
   //               diCarpeta = New  IO.DirectoryInfo(strUbicacionSecundaria)
   //               If Not diCarpeta.Exists Then diCarpeta.Create()
   //            End If
   //            '
   //            If Not SubCarpeta.Equals(String.Empty) Then
   //               strUbicacionSecundaria = strUbicacionSecundaria &  "\" & SubCarpeta
   //               diCarpeta = New  IO.DirectoryInfo(strUbicacionSecundaria)
   //               If Not diCarpeta.Exists Then diCarpeta.Create()
   //            End If
   //            '
   //            'Copiar
   //            For Each adjArchivo In ArchivosAdjuntosACopiar  'ArchivosAdjuntos
   //               If File.Exists(adjArchivo.NombreCompleto) Then
   //                  File.Copy(adjArchivo.NombreCompleto,  strUbicacionSecundaria & "\" & adjArchivo.NombreArchivo, True)
   //               End If
   //            Next
   //         End If

   //         'Eliminar
   //         For Each adjArchivo In ArchivosAdjuntosAEliminar
   //            If File.Exists(adjArchivo.NombreCompleto) Then
   //                System.IO.File.SetAttributes(adjArchivo.NombreCompleto,  IO.FileAttributes.ReadOnly = 0)
   //               File.Delete(adjArchivo.NombreCompleto)
   //            End If
   //         Next
   //         ArchivosAdjuntosAEliminar.Clear()

   //      End If
   //   Catch ex As Exception
   //      If Idioma = eIdioma.Espanol Then
   //         MensajeSegunIdioma = "Se han detectado problemas a la  hora de actualizar los archivos adjuntos: "
   //      Else
   //         MensajeSegunIdioma = "S'han detectat problemes a l'hora  d'actualitzar els arxius adjunts: "
   //      End If
   //      MsgBox(MensajeSegunIdioma & _
   //          ex.Message, MsgBoxStyle.Exclamation, "Error")
   //      'lstAdjuntos.Items.Clear()
   //   Finally
   //      If Not di Is Nothing Then di = Nothing
   //   End Try
   //End Sub
   #endregion
   //'
   //Public Sub Actualizar()
   public void ProcesarAccionesPendientes()
   {
      System.IO.DirectoryInfo di = null;
      clsArchivoAdjunto adjArchivo = null;
      System.IO.DirectoryInfo diCarpeta = null;
      string strUbicacionSecundaria = UbicacionRepositorio + "\\";
      //'
      //'
      try
      {
         if (!UbicacionRepositorio.Equals(string.Empty) && Enabled && _dicAccionesToDo.Count > 0)
         {
            //Validar carpetas
            if (!Carpeta.Equals(string.Empty))
            {
               strUbicacionSecundaria = strUbicacionSecundaria + Carpeta;
               diCarpeta = new System.IO.DirectoryInfo(strUbicacionSecundaria);
               if (!diCarpeta.Exists)
                  diCarpeta.Create();
            }
            //
            if (!SubCarpeta.Equals(string.Empty))
            {
               strUbicacionSecundaria = string.Format("{0}\\{1}", strUbicacionSecundaria, SubCarpeta);
               diCarpeta = new System.IO.DirectoryInfo(strUbicacionSecundaria);
               if (!diCarpeta.Exists)
                  diCarpeta.Create();
            }
            //
            //Realizar acciones
            foreach (string strKey in _dicAccionesToDo.Keys)
            {
               adjArchivo = _dicAccionesToDo[strKey];
               //
               //Si existe el fichero (q no se  haya borrado o renombrado desde el explorer)
               if (File.Exists(adjArchivo.NombreCompleto))
               {
                  switch (adjArchivo.AccionAdjunto)
                  {
                     case clsArchivoAdjunto.eAccionAdjunto.Agregar:
                        File.Copy(adjArchivo.NombreCompleto, string.Format("{0}\\{1}", strUbicacionSecundaria, adjArchivo.NombreArchivo), true);
                        //Si existe  el fichero lo sobreescribe
                        break;
                     case clsArchivoAdjunto.eAccionAdjunto.Eliminar:
                        System.IO.File.SetAttributes(adjArchivo.NombreCompleto, ~FileAttributes.ReadOnly);
                        File.Delete(adjArchivo.NombreCompleto);
                        break;
                  }
                  //_dicAccionesToDo.Remove(.NombreArchivo) 'Eliminar de la lista después de  procesarlo 'No se puede dentro del bucle
               }
               //
            }
            _dicAccionesToDo.Clear();
            //Eliminar de la lista después de  procesarlo
            ComprobarQuedanAdjuntosEnExplorer();
            //Borrar la carpeta de adjuntos sino quedan  ficheros
            //
         }
         //
      }
      catch (Exception ex)
      {
         if (Idioma == eIdioma.Espanol)
         {
            MensajeSegunIdioma = "Se han detectado  problemas a la hora de actualizar los archivos adjuntos: ";
         }
         else
         {
            MensajeSegunIdioma = "S'han detectat  problemes a l'hora d'actualitzar els arxius adjunts: ";
         }
         Interaction.MsgBox(MensajeSegunIdioma + ex.Message, MsgBoxStyle.Exclamation, "Error");
      }
      finally
      {
         di = null;
      }
   }
   //'
   //'
   /// <summary>
   /// Agrega al diccionario o lo quita 
   /// </summary>
   /// <param name="Accion"></param>
   /// <param name="ArchivoAdjunto"></param>
   /// <param name="bolAgregarQuitarDelListbox">Si tb lo ha de agregar  o buscar y quitar al ListBox</param>
   /// <remarks></remarks>
   private void AgregarQuitarAdjunto(clsArchivoAdjunto.eAccionAdjunto Accion, clsArchivoAdjunto ArchivoAdjunto, bool bolAgregarQuitarDelListbox = false)
   {
      string strNombreArchivo = ArchivoAdjunto.NombreArchivo;
      int intPos = 0;
      //'
      //'
      //Si existe lo reemplaza por la última Acción
      if (_dicAccionesToDo.ContainsKey(strNombreArchivo))
      {
         _dicAccionesToDo[strNombreArchivo] = ArchivoAdjunto;
      }
      else
      {
         _dicAccionesToDo.Add(strNombreArchivo, ArchivoAdjunto);
      }
      //
      if (bolAgregarQuitarDelListbox)
      {
         switch (Accion)
         {
            case clsArchivoAdjunto.eAccionAdjunto.Agregar:
               lstAdjuntos.Items.Add(ArchivoAdjunto);
               break;
            case clsArchivoAdjunto.eAccionAdjunto.Eliminar:
               intPos = lstAdjuntos.FindString(strNombreArchivo);
               if (intPos > -1)
                  lstAdjuntos.Items.RemoveAt(intPos);
               break;
         }
      }
   }
   //'
   /// <summary>
   /// Si agregas y no guardas la lista clsArchivoAdjunto a eliminar  contiene la ruta originbal del fichero y no 
   /// la de adjuntos.. entonces te borrará el original. Esto sucede  cuando control adjuntos no se cierra al guardar (como un panel de agenoma)
   /// Aquí actualizamos la lista de ficheros a borrar por la ruta  indicada
   /// </summary>
   /// <remarks></remarks>
   //ByVal RutaNuevaArchivosaEliminar As String)
   public void CorregirListaElminacionesAdjuntos()
   {
      string NombreFichero = "0";
      string RutaNuevaFileEliminar = string.Format("{0}\\{1}\\{2}", UbicacionRepositorio, Carpeta, SubCarpeta);
      clsArchivoAdjunto adjArchivo = null;
      //'
      //'
      //Añadir ruta final
      //If Strings.Right(RutaNuevaArchivosaEliminar, 1) <> "\"  Then RutaNuevaArchivosaEliminar &= "\"
      //
      //--------Obsoleto
      //Cambiar ruta de los ficheros a eliminar por la correcta
      //For Each adjArchivo As clsArchivoAdjunto In  ArchivosAdjuntosAEliminar
      //   NombreFichero =  ObtenerNombreSimple(adjArchivo.NombreCompleto)
      //   adjArchivo.NombreCompleto = RutaNuevaFileEliminar &  "\" & NombreFichero
      //Next
      //
      foreach (string strKey in _dicAccionesToDo.Keys)
      {
         adjArchivo = _dicAccionesToDo[strKey];
         var _with2 = adjArchivo;
         if (_with2.AccionAdjunto == clsArchivoAdjunto.eAccionAdjunto.Eliminar)
         {
            NombreFichero = ObtenerNombreSimple(_with2.NombreCompleto);
            _with2.NombreCompleto = string.Format("{0}\\{1}", RutaNuevaFileEliminar, NombreFichero);
         }
      }
   }
   #endregion

   #region "Utilidades Ctrl_Adjuntos"
   /// <summary>
   /// Comprueba que la descripcion del Gproy es igual que la de  adjuntos. 
   /// Sino es así muestra mensaje y actualiza según caso. Devuelve La  descripción Final
   /// </summary>
   /// <remarks></remarks>
   public string ComprobarDescripcionAdjuntosHaCambiado(string CodigoAdjuntos, string CodigoGproy, string CarpetaActualAdjuntos)
   {
      string[] DescripcionParticionada = null;
      string NuevaDescripcion = string.Empty;
      string IdActual = string.Empty;
      string Ret = string.Empty;
      int PosicionInicialBucle = 0;
      string[] PathEntries = null;
      string NombreAplicacion = string.Empty;
      string DirectorioActualAdjuntos = string.Empty;

      DirectorioActualAdjuntos = string.Format("{0}\\{1}\\", clsVariables.str_PathAdjuntos, CarpetaActualAdjuntos);
      if (Enabled && Directory.Exists(DirectorioActualAdjuntos))
      {
         IdActual = CodigoGproy.Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries)[0];
         // Strings.Left(CodigoGproy,  CodigoGproy.IndexOf("-")).Trim(), si no existe "-" (No pasa NADA)'TODO: Si  CodigoGProy ES string.Empty (PETAAAA)

         //Comprobar si la carpeta  existe y si es necesario  hacer la sincronización
         PathEntries = Directory.GetDirectories(DirectorioActualAdjuntos, IdActual + "*", SearchOption.AllDirectories);

         if (PathEntries.Length > 0)
         {
            //--Ofertas y solicitudes llevab id -  codigo - descripcion y el bucle para comparar descripciones
            //ha de empezar en 4 (base 0) pero los  demás solo llevan id - descripción así que el  bucle ha de empezar en 2  (base 0)
            if (CarpetaActualAdjuntos == "Solicitudes" || CarpetaActualAdjuntos == "Ofertas")
            {
               PosicionInicialBucle = 4;
            }
            else
            {
               PosicionInicialBucle = 2;
            }
            //----

            if (CodigoAdjuntos != CodigoGproy)
            {
               NombreAplicacion = clsVariables.str_NombreAplicacion;
               //My.Application.Info.AssemblyName

               if (Idioma == eIdioma.Espanol)
               {
                  MensajeSegunIdioma = "Se ha  detectado que en el directorio '" + clsVariables.str_PathAdjuntos + "\\" + CarpetaActualAdjuntos + "' para el ID '" + IdActual + "' existe el  directorio '" + CodigoAdjuntos + "' mientras que en '" + NombreAplicacion + "' es '" + CodigoGproy + "'" + Constants.vbNewLine + Constants.vbNewLine + "Desea cambiar la de '" + NombreAplicacion + "' para que coincida con la  del directorio? " + Constants.vbNewLine + Constants.vbNewLine + "NOTA  IMPORTANTE!: Aunque se vea reflejado, no se guardará hasta que no edite y  guarde cambios";
               }
               else
               {
                  MensajeSegunIdioma = "S'ha  detectat que en el directori '" + clsVariables.str_PathAdjuntos + "\\" + CarpetaActualAdjuntos + "' per el ID '" + IdActual + "' existeix el  directori '" + CodigoAdjuntos + "' mentres que en '" + NombreAplicacion + "' es '" + CodigoGproy + "'" + Constants.vbNewLine + Constants.vbNewLine + "Desitja canviar la de '" + NombreAplicacion + "' perquè coincideixi amb la  del directori?" + Constants.vbNewLine + Constants.vbNewLine + "NOTA  IMPORTANT!: Encara que es vegi reflectit, no es guardarà fins que no editi  i guardi canvis";
               }

               if (MessageBox.Show(MensajeSegunIdioma, clsVariables.str_NombreAplicacion, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
               {
                  //Extraer descripción nueva
                  DescripcionParticionada = CodigoAdjuntos.Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
                  for (int x = PosicionInicialBucle; x <= DescripcionParticionada.Length - 1; x++)
                  {
                     NuevaDescripcion += DescripcionParticionada[x] + " ";
                  }
                  if (!string.IsNullOrEmpty(NuevaDescripcion))
                  {
                     Ret = Strings.Left(NuevaDescripcion, Strings.Len(NuevaDescripcion) - 1);
                  }
               }
            }
         }
      }

      return Ret;
   }

   /// <summary>
   /// Recorre el directorio de adjuntos y  cuando encuentra el id del  control adjuntos actual lo renombra
   /// </summary>
   /// <remarks></remarks>
   public void CambiarNombreAdjunto()
   {
      string idaBuscar = string.Empty;
      string CarpetaPrograma = string.Empty;
      string strUbicacionSecundaria = null;
      DirectoryInfo diSubcarpetas = null;
      //'
      if (Enabled)
      {
         //Componer ubicación archivos
         strUbicacionSecundaria = string.Format("{0}\\", UbicacionRepositorio);
         if (!Carpeta.Equals(string.Empty))
            strUbicacionSecundaria = string.Format("{0}{1}\\", strUbicacionSecundaria, Carpeta);
         //
         if (Directory.Exists(strUbicacionSecundaria))
         {
            //Comprobar solo hay una carpeta con ese Id  Subcarpeta
            diSubcarpetas = new DirectoryInfo(strUbicacionSecundaria);
            idaBuscar = SubCarpeta.Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries)[0];
            //idaBuscar = Strings.Left(SubCarpeta,  SubCarpeta.IndexOf("-")).Trim()

            string IdDirectorioActual = null;
            foreach (DirectoryInfo Path in diSubcarpetas.GetDirectories())
            {
               //Si se ha puesto guiones (en  principio siempre)
               if (Strings.InStr(Path.Name, "-") > 0)
               {
                  IdDirectorioActual = Strings.Left(Path.Name, Path.Name.IndexOf("-")).Trim();
               }
               else
               {
                  IdDirectorioActual = Path.Name;
               }
               //comparamos actual subcarpeta con  ID
               if (IdDirectorioActual == idaBuscar)
               {
                  //Cambiamos nombre
                  //Rename(Path.FullName,  strUbicacionSecundaria & SubCarpeta)
                  CarpetaPrograma = strUbicacionSecundaria + SubCarpeta;
                  try
                  {
                     if (Path.FullName != CarpetaPrograma)
                     {
                        //My.Computer.FileSystem.RenameDirectory(Path.FullName, CarpetaPrograma)
                        FileSystem.Rename(Path.FullName, CarpetaPrograma);
                     }
                  }
                  catch (Exception ex)
                  {
                     Interaction.MsgBox("La carpeta no ha podido ser renombrada." + Constants.vbCrLf + "Compruebe que no tenga ningún archivo abierto." + Constants.vbCrLf + Constants.vbCrLf + "error detallado: " + ex.ToString());
                  }
                  break; // TODO: might not  be correct. Was : Exit For
               }
            }
         }
         else
         {
            Console.WriteLine(strUbicacionSecundaria + " directorio no existe. (CambiarNombreAdjunto de Ctrl_Adjuntos)");
         }

      }

   }

   /// <summary>
   /// Devuelve true si la carpeta que estamos intentando crear ya  existe en adjuntos y tiene ficheros
   /// También llama a MasDeUnIdEnCarpetaAdjuntos
   /// </summary>
   /// <returns></returns>
   /// <remarks></remarks>
   public bool CarpetaAdjuntosExisteyTieneFicheros(ref Ctrl_Adjuntos ControlAdjuntos, bool bolMensaje = true)
   {
      //TODO: Explicacion parametros
      bool Ret = false;
      DataTable dt = null;
      int Contador = 0;
      string DirectorioaExaminar = null;
      string sSQlconMax = string.Empty;


      if (Enabled)
      {
         if (string.IsNullOrEmpty(ControlAdjuntos.SubCarpeta.Trim()) || ControlAdjuntos.SubCarpeta.Trim() == "0")
         {
            //Comprobar si el número MAX ya existe en  adjuntos 
            DirectorioaExaminar = ControlAdjuntos.UbicacionRepositorio + "\\" + ControlAdjuntos.Carpeta + "\\";
            sSQlconMax = "SELECT MAX(" + ObtenerPrimaryKeyTabla(ControlAdjuntos.Carpeta) + ") FROM " + ControlAdjuntos.Carpeta;
         }
         else
         {
            DirectorioaExaminar = ControlAdjuntos.UbicacionRepositorio + "\\" + ControlAdjuntos.Carpeta + "\\" + ControlAdjuntos.SubCarpeta + "\\";
         }


         if (sSQlconMax != string.Empty)
         {
            //Obtener MAX
            dt = ObtenerDt(sSQlconMax);
            if (Information.IsDBNull(dt.Rows[0][0]))
            {
               Contador = 1;
            }
            else
            {
               Contador = ((int)dt.Rows[0][0]) + 1;
            }
         }
         else
         {
            Contador = 0;
         }

         if (Contador != 0)
            DirectorioaExaminar = DirectorioaExaminar + Contador;

         //Comprobar carpeta
         //Solo puedo hacer aquí MasDeUnIdEnCarpetaAdjuntos  pq. aquí es donde se sabe el max q le toca
         if (MasDeUnIdEnCarpetaAdjuntos(Contador, ControlAdjuntos.UbicacionRepositorio + "\\" + ControlAdjuntos.Carpeta + "\\", 0))
            Ret = true;

         if (Ret == false)
         {
            if (System.IO.Directory.Exists(DirectorioaExaminar) && System.IO.Directory.GetFiles(DirectorioaExaminar).Length > 0)
            {
               //If MsgBox("La carpeta '" &  DirectorioaExaminar & "' ya contiene una carpeta de adjuntos con el nombre  '" & Contador & "'. " & vbNewLine & _
               //          "Si continua se  agregarán los adjuntos a esa carpeta y puede originar adjuntos  incoherentes. " & vbNewLine & _
               //          "Desea eliminar la  carpeta de adjuntos existente (" & Contador & ") primero?", _
               //          MsgBoxStyle.Exclamation  + MsgBoxStyle.YesNo + MsgBoxStyle.DefaultButton2,  My.Application.Info.AssemblyName) = MsgBoxResult.Yes Then
               //    EliminarCarpetaDefinitivo(DirectorioaExaminar & Contador, True)
               Ret = true;

               if (Idioma == eIdioma.Espanol)
               {
                  MensajeSegunIdioma = "La  carpeta '" + DirectorioaExaminar + "' ya contiene archivos adjuntos." + Constants.vbNewLine + "El proceso de alta no continuará." + Constants.vbNewLine + "Desea abrir la carpeta ahora para comprobar su  contenido?";
               }
               else
               {
                  MensajeSegunIdioma = "La  carpeta '" + DirectorioaExaminar + "' ja conté arxius adjunts." + Constants.vbNewLine + "El procés d'alta no continuarà." + Constants.vbNewLine + "Desitja obrir la carpeta ara per a comprovar el seu  contingut?";
               }

               if (bolMensaje)
               {
                  if (Interaction.MsgBox(MensajeSegunIdioma, MsgBoxStyle.Exclamation, clsVariables.str_NombreAplicacion) == MsgBoxResult.Yes)
                  {
                     System.Diagnostics.Process.Start("explorer.exe", DirectorioaExaminar);
                  }
               }
            }
            else
            {
               Ret = false;
            }
         }


      }

      return Ret;
   }

   /// <summary>
   /// Eliminar un directorio y devuelve true si indicamos que si al  mensaje de borrado
   /// </summary>
   /// <param name="SeccionEscogida"></param>
   /// <param name="CodigoEscogido"></param>
   /// <param name="BorrarSinMostrarAdvertenciaAdjuntos"></param>
   /// <returns></returns>
   /// <remarks></remarks>
   public bool EliminarCarpetaAdjuntos(string SeccionEscogida, string CodigoEscogido, bool BorrarSinMostrarAdvertenciaAdjuntos = false)
   {
      bool Ret = false;

      if (clsVariables.str_PathAdjuntos != string.Empty)
      {
         string DirectorioaBorrarAdjuntos = clsVariables.str_PathAdjuntos + "\\" + SeccionEscogida + "\\" + CodigoEscogido;
         Ret = EliminarCarpetaDefinitivo(DirectorioaBorrarAdjuntos, BorrarSinMostrarAdvertenciaAdjuntos);
      }
      else
      {
         Ret = true;
      }

      return Ret;
   }

   /// <summary>
   /// Devuelve true si exise mas de una carpeta con ese id en  adjuntos
   /// Si solo existe una la asigna a .Subcarpeta
   /// </summary>
   /// <param name="idCompletoABuscar"></param>
   /// <param name="StrRuta">Sino se le pasa ruta la cálcula  automáticamente</param>
   /// <returns></returns>
   /// <remarks></remarks>
   public bool MasDeUnIdEnCarpetaAdjuntos(string idCompletoABuscar, string StrRuta, int MaximosPermitidos = 1)
   {
      bool Ret = false;
      string IdDirectorioActual = null;
      int Resultados = 0;
      // Dim FileEntries As String()
      //Dim DirectoriosVaciosABorrar As New ArrayList
      DirectoryInfo diSubcarpetas = new DirectoryInfo(StrRuta);
      string DirectorioActual = string.Empty;

      //If StrRuta = "" Then
      //   'Componer ubicación archivos
      //   StrRuta = UbicacionRepositorio & "\"
      //   If Not Carpeta.Equals(String.Empty) Then
      //      StrRuta = StrRuta & Carpeta & "\"
      //   End If
      //   'Si solo hay un directorio con ese id seguimos
      //   If Not SubCarpeta.Equals(String.Empty) Then
      //      StrRuta = StrRuta & SubCarpeta & "\"
      //   End If
      //End If

      if (Enabled && Directory.Exists(StrRuta))
      {
         if (Strings.InStr(idCompletoABuscar, "-") > 0)
         {
            idCompletoABuscar = Strings.Left(idCompletoABuscar, idCompletoABuscar.IndexOf("-")).Trim();
         }

         foreach (DirectoryInfo Path in diSubcarpetas.GetDirectories())
         {
            //Si se ha puesto guiones (en principio  siempre)
            if (Strings.InStr(Path.Name, "-") > 0)
            {
               IdDirectorioActual = Strings.Left(Path.Name, Path.Name.IndexOf("-")).Trim();
            }
            else
            {
               IdDirectorioActual = Path.Name;
            }
            //comparamos actual subcarpeta con ID
            if (IdDirectorioActual == idCompletoABuscar)
            {
               //Comprobar si tiene ficheros y  sino borrar
               //FileEntries =  Directory.GetFiles(Path.FullName, "*.*", SearchOption.AllDirectories)
               //If FileEntries.Length = 0 Then
               //    DirectoriosVaciosABorrar.Add(Path.FullName)
               //Else
               Resultados += 1;
               if (Resultados > MaximosPermitidos)
               {
                  Ret = true;

                  if (Idioma == eIdioma.Espanol)
                  {
                     MensajeSegunIdioma = "Existe mas de un directorio en '" + StrRuta + "' con el Id: '" + idCompletoABuscar + "'" + Constants.vbNewLine + "El proceso con archivos no  continuará..." + Constants.vbNewLine + Constants.vbNewLine + "Desea abrir  la carpeta adjuntos para revisarlo?";
                  }
                  else
                  {
                     MensajeSegunIdioma = "Existeix mes d'un directori en '" + StrRuta + "' amb el Id: '" + idCompletoABuscar + "'" + Constants.vbNewLine + "El procés amb fitxers no  continuarà..." + Constants.vbNewLine + Constants.vbNewLine + "Desitja obrir  la carpeta adjunts per a revisar-lo?";
                  }

                  if (MessageBox.Show(MensajeSegunIdioma, clsVariables.str_NombreAplicacion, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation,
                     MessageBoxDefaultButton.Button1) == DialogResult.Yes)
                  {
                     System.Diagnostics.Process.Start("explorer.exe", StrRuta);
                  }
                  break; // TODO: might not  be correct. Was : Exit For
               }
               else
               {
                  DirectorioActual = Path.Name;
               }
               //End If

            }
         }

         //Solo hay uno entramos en la comprobación de la  descripción
         if (Resultados == 1)
         {
            if (SubCarpeta != DirectorioActual)
            {
               //If MsgBox("Se ha detectado que el  directorio para el ID " & m_IDActual & " tiene la descripción '" & _
               //          DirectorioActual & "'  mientras que la descripción del Gproy es '" & SubCarpeta & "'" & vbNewLine  & vbNewLine & _
               //          "Desea cambiar la  descripción del Gproy para que coincida con la de la carpeta?",  MsgBoxStyle.Information + MsgBoxStyle.YesNo,  My.Application.Info.AssemblyName) = MsgBoxResult.Yes Then
               SubCarpeta = DirectorioActual;
               //End If
            }
         }

         //Borrar directorios vacíos
         //For Each strDirectorio As String In  DirectoriosVaciosABorrar
         //   If  System.IO.Directory.GetDirectories(strDirectorio).Length > 0 Then
         //      MsgBox("No se puede borrar un directorio  con subdirectorios en modo solo lectura programaticamente. Eliminelos a  mano." & vbNewLine & _
         //             strDirectorio,  MsgBoxStyle.Information, My.Application.Info.AssemblyName)
         //   Else
         //      System.IO.Directory.Delete(strDirectorio,  True)
         //   End If
         //Next

      }

      return Ret;
   }
   #endregion

   #region "               Obsoleto.. de momento"
   ///'' <summary>
   ///'' Cuando Guardamos como nuevo los archivos adjuntos solo coge  los agregados recientemente
   ///'' Esto lo corrige
   ///'' </summary>
   ///'' <returns></returns>
   ///'' <remarks></remarks>
   //Public Function ActualizarArchivosAdjuntosaCopiar() As Boolean
   //   Dim NuevaclsArchivoAdjunto As clsArchivoAdjunto

   //   For Each archivo As clsArchivoAdjunto In ArchivosAdjuntos
   //      If BuscarArchivosAdjuntosACopiar(archivo.NombreCompleto) =  False Then
   //         'Adjuntamos a ArchivosAdjuntosACopiar
   //         NuevaclsArchivoAdjunto = New clsArchivoAdjunto
   //         With NuevaclsArchivoAdjunto
   //            .NombreCompleto = archivo.NombreCompleto  'OpenFileDialog.FileName
   //            .NombreArchivo = archivo.NombreArchivo
   //            .Nuevo = True
   //         End With
   //         _colArchivosAdjuntosACopiar.Add(NuevaclsArchivoAdjunto)
   //         'ArchivosAdjuntosACopiar.Add(NuevaclsArchivoAdjunto)
   //         'Dim iteArchivo As Object
   //         '_colArchivosAdjuntos.Clear()
   //         'For Each iteArchivo In lstAdjuntos.Items
   //         '   _colArchivosAdjuntos.Add(iteArchivo)
   //         'Next

   //      End If
   //   Next
   //End Function

   ///' <summary>
   ///' Busca un NombreCompleto dentro de ArchivosAdjuntosACopiar y  devuelve true si lo encuentra
   ///' </summary>
   ///' <param name="strarchivo"></param>
   ///' <returns></returns>
   ///' <remarks></remarks>
   //Public Function BuscarArchivosAdjuntosACopiar(ByVal strarchivo As  String) As Boolean
   //   Dim Ret As Boolean = False

   //   For Each archivo As clsArchivoAdjunto In  ArchivosAdjuntosACopiar
   //      If archivo.NombreCompleto.Trim() = strarchivo.Trim() Then
   //         Ret = True
   //         Exit For
   //      End If
   //   Next

   //   Return Ret
   //End Function
   #endregion

   #region "CargarArchivos"

   /// <summary>
   /// Devuelve la ruta completa de adjuntos en este momento. Ej:  P:\GPROY\Adjuntos\Ofertas\829 - HT0900AGC - Descrip1
   /// </summary>
   /// <returns></returns>
   /// <remarks></remarks>
   private string ObtenerRutaCompletaAdjuntos()
   {
      //Componer ubicación archivos
      string strUbicacionSecundaria = string.Empty;
      //'
      if (Enabled)
      {
         strUbicacionSecundaria = string.Format("{0}\\", UbicacionRepositorio);
         if (!Carpeta.Equals(string.Empty))
            strUbicacionSecundaria = string.Format("{0}{1}\\", strUbicacionSecundaria, Carpeta);
         //Si solo hay un directorio con ese id seguimos
         if (!SubCarpeta.Equals(string.Empty))
            strUbicacionSecundaria = string.Format("{0}{1}\\", strUbicacionSecundaria, SubCarpeta);
      }

      return strUbicacionSecundaria;
   }
   //'
   /// <summary>
   /// Devuelve true si se produjo la carga de archivos o si el  directorio de adjuntos no existe y false sino se produjo la carga
   /// </summary>
   /// <returns></returns>
   /// <remarks></remarks>
   public bool CargarArchivos()
   {
      string IDaBuscar = string.Empty;
      bool Ret = false;
      string CarpetaAdjuntos = string.Empty;

      try
      {
         if (Enabled)
         {

            if (!UbicacionRepositorio.Equals(string.Empty))
            {
               //Dim adjArchivo As  clsArchivoAdjunto
               //Dim diCarpeta As IO.DirectoryInfo

               //Componer ubicación archivos
               string strUbicacionSecundaria = UbicacionRepositorio + "\\";
               if (!Carpeta.Equals(string.Empty))
               {
                  strUbicacionSecundaria = string.Format("{0}{1}\\", strUbicacionSecundaria, Carpeta);
               }
               //
               //Si solo hay un directorio con ese  id seguimos
               if (!SubCarpeta.Equals(string.Empty))
                  strUbicacionSecundaria = string.Format("{0}{1}\\", strUbicacionSecundaria, SubCarpeta);
               //
               //Comprobar si id+descripcion  existe y sino asignarle solo Id
               //If Not  System.IO.Directory.Exists(strUbicacionSecundaria) Then
               //   Dim Directorio As String =  String.Empty
               //   Dim IdTratado As String()
               //   Dim d As New  DirectoryInfo(strUbicacionSecundaria)
               //   'Sino se encuentra por el  nombre pasado dar opción de buscar por ID
               //   IdTratado =  SubCarpeta.Split("-")
               //   'Obtengo solo el ID para  buscar por él
               //   strUbicacionSecundaria =  d.Parent.FullName & "\" & IdTratado(0).Trim() & "\"
               //End If
               CarpetaAdjuntos = string.Format("{0}\\{1}\\", UbicacionRepositorio, Carpeta);
               if (Directory.Exists(CarpetaAdjuntos) && MasDeUnIdEnCarpetaAdjuntos(m_IDActual, UbicacionRepositorio + "\\" + Carpeta + "\\", 1) == false)
               {
                  //Comprobar de nuevo la 
                  strUbicacionSecundaria = ObtenerRutaCompletaAdjuntos();

                  //Obtener lista de archivos
                  if (System.IO.Directory.Exists(strUbicacionSecundaria))
                  {
                     DirectoryInfo diCarpeta = new DirectoryInfo(strUbicacionSecundaria);
                     FileInfo[] fiArchivos = null;
                     clsArchivoAdjunto adjArchivo = null;
                     fiArchivos = diCarpeta.GetFiles("*.*");
                     foreach (FileInfo diArchivo in fiArchivos)
                     {
                        adjArchivo = new clsArchivoAdjunto();
                        var _with4 = adjArchivo;
                        _with4.Nuevo = false;
                        _with4.NombreCompleto = diArchivo.FullName;
                        _with4.NombreArchivo = ObtenerNombreSimple(_with4.NombreCompleto);
                        lstAdjuntos.Items.Add(adjArchivo);
                        Ret = true;
                     }
                  }
                  else
                  {
                     Ret = true;
                  }

               }
               else
               {
                  Ret = false;
               }

            }
         }
         else
         {
            Ret = true;
         }
         return Ret;
         //
      }
      catch (Exception ex)
      {
         Interaction.MsgBox(ex.Message, MsgBoxStyle.Critical, "Error");
      }
   }

   #endregion

   #region "Alta"
   private void btnAltaModulos_Click(System.Object sender, System.EventArgs e)
   {
      int intPos = 0;
      clsArchivoAdjunto adjArchivo = null;
      string[] Escogidos = null;
      //'
      //'
      if (OpenFileDialog.ShowDialog == System.Windows.Forms.DialogResult.OK)
      {
         Escogidos = OpenFileDialog.FileNames;
         //
         foreach (string fichEscogido in Escogidos)
         {
            adjArchivo = new clsArchivoAdjunto();
            var _with5 = adjArchivo;
            _with5.NombreCompleto = fichEscogido;
            //OpenFileDialog.FileName
            _with5.NombreArchivo = ObtenerNombreSimple(_with5.NombreCompleto);
            _with5.Nuevo = true;
            intPos = lstAdjuntos.FindString(adjArchivo.NombreArchivo);
            //
            if (intPos > -1)
            {
               if (Idioma == eIdioma.Espanol)
               {
                  MensajeSegunIdioma = "Se ha  detectado un archivo adjunto existente con el mismo nombre. " + "¿Desea  sobrescribirlo?";
               }
               else
               {
                  MensajeSegunIdioma = "S'ha  detectat un arxiu adjunt existent amb el mateix nom." + "¿Desitja  sobrescriure'l?";
               }

               if (Interaction.MsgBox(MensajeSegunIdioma, MsgBoxStyle.Exclamation + MsgBoxStyle.YesNo + MsgBoxStyle.DefaultButton2, "Advertencia") == MsgBoxResult.Yes)
               {
                  lstAdjuntos.Items.RemoveAt(intPos);
                  lstAdjuntos.Items.Add(adjArchivo);
               }
            }
            else
            {
               lstAdjuntos.Items.Add(adjArchivo);
               adjArchivo.AccionAdjunto = clsArchivoAdjunto.eAccionAdjunto.Agregar;
               AgregarQuitarAdjunto(clsArchivoAdjunto.eAccionAdjunto.Agregar, adjArchivo);
            }
         }
         //
      }
   }
   #endregion
   //'
   #region "Baja"
   private void btnBajaModulo_Click(System.Object sender, System.EventArgs e)
   {
      clsArchivoAdjunto oArchivoAdjunto = null;
      //'
      if (lstAdjuntos.SelectedIndex >= 0)
      {
         oArchivoAdjunto = lstAdjuntos.Items(lstAdjuntos.SelectedIndex);
         oArchivoAdjunto.AccionAdjunto = clsArchivoAdjunto.eAccionAdjunto.Eliminar;
         AgregarQuitarAdjunto(clsArchivoAdjunto.eAccionAdjunto.Eliminar, oArchivoAdjunto);
         //_colArchivosAdjuntosAEliminar.Add(lstAdjuntos.Items(lstAdjuntos.SelectedI ndex))
         lstAdjuntos.Items.RemoveAt(lstAdjuntos.SelectedIndex);
      }
      //      
   }
   //'
   /// <summary>
   /// SIno queda ningún adjunto en la carpeta, borra la carpeta
   /// </summary>
   /// <remarks></remarks>
   private void ComprobarQuedanAdjuntosEnExplorer()
   {
      string DirectorioAdjuntosActual = string.Format("{0}\\{1}\\{2}", UbicacionRepositorio, Carpeta, SubCarpeta);
      //'
      //Si ya no hay archivos adjuntos eliminar la carpeta
      if ((SubCarpeta != null) && lstAdjuntos.Items.Count == 0 && !string.IsNullOrEmpty(SubCarpeta.Trim()) && Directory.Exists(DirectorioAdjuntosActual))
      {
         System.IO.Directory.Delete(DirectorioAdjuntosActual, true);
      }
   }
   #endregion
   //'
   #region "ObtenerNombreSimple"

   private string ObtenerNombreSimple(string prmNombreCompleto)
   {
      string[] strParticionado = null;
      strParticionado = Strings.Split(prmNombreCompleto, "\\");
      return strParticionado[strParticionado.GetUpperBound(0)];
   }

   #endregion

   #region "                                         Envío Mail con  PDF"
   //Private Sub btnSendMail_Click(ByVal sender As System.Object,  ByVal e As System.EventArgs) Handles btnSendMail.Click
   //   If lstAdjuntos.SelectedIndex >= 0 Then

   //      If  Strings.Right(lstAdjuntos.Items(lstAdjuntos.SelectedIndex).nombrearchivo,  4) = ".pdf" Then
   //         'Es pdf
   //         Dim SmtpMail As New SmtpSendMail.frmSmtpSendMail(Me)
   //         SmtpMail.Show()
   //      Else
   //         MsgBox("Solo se pueden enviar archivos adjuntos con la  extensión '.pdf'", MsgBoxStyle.Information,  My.Application.Info.AssemblyName)
   //      End If

   //   End If
   //End Sub
   #endregion


   private void lstAdjuntos_DoubleClick(object sender, System.EventArgs e)
   {
      try
      {
         clsArchivoAdjunto adjArchivo = null;
         adjArchivo = lstAdjuntos.Items(lstAdjuntos.SelectedIndex);
         System.Diagnostics.Process.Start(adjArchivo.NombreCompleto);
      }
      catch (Exception ex)
      {
         Interaction.MsgBox(ex.Message, MsgBoxStyle.OkOnly + MsgBoxStyle.Critical, "Error");
      }
   }

   private void btnAbrirRuta_Click(System.Object sender, System.EventArgs e)
   {
      string RutaCompletaCarpeta = string.Empty;

      RutaCompletaCarpeta = UbicacionRepositorio + "\\" + Carpeta + "\\" + SubCarpeta;
      if (Directory.Exists(RutaCompletaCarpeta))
      {
         System.Diagnostics.Process.Start("explorer.exe", "\"" + RutaCompletaCarpeta + "\"");
      }
      else
      {
         if (Idioma == eIdioma.Espanol)
         {
            MensajeSegunIdioma = string.Format("No se  puede abrir la ruta: '{0}'. Es posible que el archivo adjunto aun no se  haya creado", RutaCompletaCarpeta);
         }
         else
         {
            MensajeSegunIdioma = string.Format("No es  pot obrir la ruta: '{0}'. És possible que l'arxiu adjunt encara no s'hagi  creat", RutaCompletaCarpeta);
         }

         Interaction.MsgBox(MensajeSegunIdioma, MsgBoxStyle.Information, My.Application.Info.AssemblyName);
      }
   }
   //'
   #region " ToolTips"
   private void btnAltaModulos_MouseHover(System.Object sender, System.EventArgs e)
   {
      if (Idioma == eIdioma.Espanol)
      {
         MensajeSegunIdioma = "Agregar Fichero";
      }
      else
      {
         MensajeSegunIdioma = "Agregar Fitxer";
      }
      MostrarMensajeToolTip(ref sender, MensajeSegunIdioma);
   }

   private void btnBajaModulo_MouseHover(System.Object sender, System.EventArgs e)
   {
      if (Idioma == eIdioma.Espanol)
      {
         MensajeSegunIdioma = "Borrar fichero actualmente  seleccionado";
      }
      else
      {
         MensajeSegunIdioma = "Esborrar fitxer actualment  seleccionat";
      }
      MostrarMensajeToolTip(ref sender, MensajeSegunIdioma);
   }

   private void btnSendMail_MouseHover(System.Object sender, System.EventArgs e)
   {
      if (Idioma == eIdioma.Espanol)
      {
         MensajeSegunIdioma = "Enviar fichero pdf por mail";
      }
      else
      {
         MensajeSegunIdioma = "Enviar fitxer pdf per mail";
      }
      MostrarMensajeToolTip(ref sender, MensajeSegunIdioma);
   }

   private void btnAbrirRuta_MouseHover(System.Object sender, System.EventArgs e)
   {
      if (Idioma == eIdioma.Espanol)
      {
         MensajeSegunIdioma = "Abrir ruta contenedora  archivos adjuntos";
      }
      else
      {
         MensajeSegunIdioma = "Obrir ruta contenidora arxius  adjunts";
      }
      MostrarMensajeToolTip(ref sender, MensajeSegunIdioma);
   }

   private void MostrarMensajeToolTip(ref System.Object ObjSender, string MensajeMostrado)
   {
      if (ToolTipGenerico == null)
         ToolTipGenerico = new System.Windows.Forms.ToolTip();

      var _with6 = ToolTipGenerico;
      _with6.IsBalloon = true;
      _with6.SetToolTip(ObjSender, MensajeMostrado);
   }
   #endregion
   //'
   #region "         PropioControlAdjuntos"
   /// <summary>
   /// Solo devuelve el primer campo de la Primary Key
   /// </summary>
   /// <param name="NombreTabla"></param>
   /// <returns></returns>
   /// <remarks></remarks>
   public string ObtenerPrimaryKeyTabla(string NombreTabla)
   {
      string Ret = string.Empty;
      string Ssql = string.Empty;
      DataTable dt = new DataTable();

      Ssql = " SELECT KU.column_name ";
      Ssql += " FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC  ";
      Ssql += " INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS  KU ";
      Ssql += " ON TC.CONSTRAINT_TYPE = 'PRIMARY KEY' ";
      Ssql += " AND TC.CONSTRAINT_NAME = KU.CONSTRAINT_NAME ";
      Ssql += " WHERE KU.TABLE_NAME = '" + NombreTabla + "' ";

      dt = ObtenerDt(Ssql);
      Ret = dt.Rows[0][0].ToString();
      return Ret;
   }

   /// <summary>
   /// Eliminar un directorio (y sus archivos) y devuelve true si  indicamos que si al mensaje de borrado
   /// </summary>
   /// <param name="DirectorioaBorrar"></param>
   /// <returns></returns>
   /// <remarks></remarks>
   public bool EliminarCarpetaDefinitivo(string DirectorioaBorrar, bool BorrarSinMostrarAdvertencia = false)
   {
      bool Ret = false;
      string MensajeTextBox = null;
      string[] fileEntries = null;
      string Directorio = string.Empty;
      string Fichero = string.Empty;
      ArrayList RutaSeparada = new ArrayList();

      if (!System.IO.Directory.Exists(DirectorioaBorrar))
      {
         //Sino se encuentra por el nombre pasado dar opción  de buscar por ID
         RutaSeparada = SepararFicheroDeRuta(DirectorioaBorrar);
         Directorio = RutaSeparada[0];
         Fichero = RutaSeparada[1];
         //Obtengo solo el ID para buscar por él
         Fichero = Strings.Left(Fichero, Fichero.IndexOf("-")).Trim();
         if (System.IO.Directory.Exists(Directorio + Fichero))
         {
            DirectorioaBorrar = Directorio + Fichero;
         }
         else
         {
            return true;
         }
      }

      fileEntries = System.IO.Directory.GetFiles(DirectorioaBorrar);

      //COmprobar archivos adjuntos

      if (fileEntries.Length > 0 && BorrarSinMostrarAdvertencia == false)
      {
         if (Idioma == eIdioma.Espanol)
         {
            MensajeSegunIdioma = "Se han detectado  archivos en la carpeta: '" + DirectorioaBorrar + "'" + Constants.vbNewLine + "¿Desea borrar los archivos?: " + Constants.vbNewLine + Constants.vbNewLine;
         }
         else
         {
            MensajeSegunIdioma = "S'han detectat arxius  en la carpeta: '" + DirectorioaBorrar + "'" + Constants.vbNewLine + "Desitja esborrar els arxius?: " + Constants.vbNewLine + Constants.vbNewLine;
         }

         MensajeTextBox = MensajeSegunIdioma;

         foreach (string ArchivoAdjunto in fileEntries)
         {
            MensajeTextBox += " - " + Strings.Replace(ArchivoAdjunto, DirectorioaBorrar + "\\", string.Empty) + Constants.vbNewLine;
         }

         if (Idioma == eIdioma.Espanol)
         {
            MensajeTextBox += Constants.vbNewLine + "Si  escoge que NO se cancelará la eliminación.";
         }
         else
         {
            MensajeTextBox += Constants.vbNewLine + "Si  escull que NO es cancel·larà l'eliminació.";
         }

         if (Interaction.MsgBox(MensajeTextBox, MsgBoxStyle.YesNo + MsgBoxStyle.DefaultButton2 + Constants.vbQuestion, My.Application.Info.AssemblyName) == MsgBoxResult.Yes)
         {
            //Borrando adjuntos
            Ret = true;
            foreach (string Archivo in fileEntries)
            {
               System.IO.File.SetAttributes(Archivo, System.IO.FileAttributes.ReadOnly == 0);
            }
            System.IO.Directory.Delete(DirectorioaBorrar, true);
         }
         else
         {
            //Throw New Exception(String.Empty)
            Ret = false;
         }
      }
      else
      {
         Ret = true;
         foreach (string Archivo in fileEntries)
         {
            System.IO.File.SetAttributes(Archivo, System.IO.FileAttributes.ReadOnly == 0);
         }
         System.IO.Directory.Delete(DirectorioaBorrar, true);
      }

      return Ret;
   }

   /// <summary>
   /// Le pasa una ruta y te devuelve un arraylist donde la posición 0  es la ruta y la posición 1 es el archivo
   /// ej: D:\Temp\a\1.pdf Devuelve 'D:\Temp\a\' en posición 0 y  '1.pdf' en posición 1
   /// </summary>
   /// <param name="prmNombreCompleto"></param>
   /// <returns></returns>
   /// <remarks></remarks>
   public static ArrayList SepararFicheroDeRuta(string prmNombreCompleto)
   {
      string[] strParticionado = null;
      ArrayList Separacion = new ArrayList();
      string Ruta = string.Empty;

      strParticionado = Strings.Split(prmNombreCompleto, "\\");
      for (int x = 0; x <= strParticionado.Length - 2; x++)
      {
         Ruta += strParticionado[x] + "\\";
      }

      Separacion.Add(Ruta);
      Separacion.Add(strParticionado[strParticionado.GetUpperBound(0)]);
      //Return strParticionado(strParticionado.GetUpperBound(0))
      return Separacion;
   }


   #region "                                                                ExecuteSQLSelect"

   /// <summary>
   /// Ejecutar un commando SQL.
   /// </summary>
   /// <param name="selectCommandText">Commando SQL a procesar</param>
   /// <returns>Tabla resultado</returns>
   /// <remarks></remarks>
   public static DataTable ObtenerDt(string selectCommandText, bool bolLanzarMjeError = true)
   {
      DataTable dt = null;
      System.Data.SqlClient.SqlDataAdapter DataAdapter = null;
      DataSet dataSet = null;

      try
      {
         if (!selectCommandText.Equals(string.Empty))
         {
            //-----
            //Inicializar 
            //connection.Open()
            DataAdapter = new System.Data.SqlClient.SqlDataAdapter(selectCommandText, Configuracion.Entorno.OrigenDeDatosCliente);
            dataSet = new DataSet();
            DataAdapter.Fill(dataSet, "DATOS");
            dt = dataSet.Tables[0];
            //connection.Close()
         }
      }
      catch (Exception ex)
      {
         if ((dataSet != null)) { dataSet.Dispose(); dataSet = null; }
         if ((DataAdapter != null)) { DataAdapter.Dispose(); DataAdapter = null; }
         Interaction.MsgBox(ex.Message, MsgBoxStyle.Critical, clsVariables.str_NombreAplicacion);
      }
      return dt;
   }

   #endregion
   #endregion

   //------------------------------------------------------------------------- -------------------------------


   #region "                  Propio Agenoma"
   /// <summary>
   /// Establece el valor del control según sea Infragistics o NET.  Después de establecerlo lo devuelve
   /// </summary>
   /// <param name="objControl"></param>
   /// <returns></returns>
   /// <remarks></remarks>
   private static object EstablecerValorDelControl(ref dynamic objControl, object oValorControl)
   {
      object oControl = (object)objControl;
      try
      {
         oControl.value = oValorControl;
         return oControl.value;
      }
      catch (Exception ex)
      {
         try
         {
            oControl.Text = oValorControl;
            return oControl.Text;
         }
         catch (Exception ex2)
         {
            Interaction.MsgBox(ex.Message, MsgBoxStyle.Exclamation, "Error");
            return string.Empty;
         }
      }
   }
   //'
   /// <summary>
   /// Infragistics devuelve value, NET devuelve text
   /// </summary>
   /// <param name="objControl"></param>
   /// <returns></returns>
   /// <remarks></remarks>
   private static object DevolverValorDelControl(ref Control objControl)
   {
      object Ret = null;
      try
      {
         Ret = ((object)objControl).Value;
         return Ret;
      }
      catch (Exception ex)
      {
         try
         {
            Ret = objControl.Text;
            return Ret;
         }
         catch (Exception ex2)
         {
            Interaction.MsgBox(ex.Message, MsgBoxStyle.Exclamation, "Error");
            return string.Empty;
         }
      }
   }
   //'
   /// <summary>
   /// Inicializar o cargar adjuntos en control. Ha de estar informado 
   /// </summary>
   /// <param name="Accion">Accion Mto16 Agenoma</param>
   /// <param name="bolActivarControl">Poner el control en  Enabled?</param>
   /// <remarks></remarks>
   public void IniciarCargarControlAdjuntos(EAccion Accion, bool bolActivarControl = true)
   {
      bool bolSeguir = true;
      int id = 0;
      string DescripcíonFinal = null;
      string txt = null;
      string sSubCarpeta = null;
      string sCarpeta = p_strSubCarpetaindicada;
      // '"agiKnowCliente"
      //'
      id = DevolverValorDelControl(ref p_CtrlContieneId);
      txt = DevolverValorDelControl(ref  p_CtrlContieneDescripcion);
      sSubCarpeta = string.Format("{0} - {1}", id, txt).Trim();
      //Cargar control adjuntos
      this.Enabled = true;
      this.UbicacionRepositorio = clsVariables.str_PathAdjuntos;
      this.Carpeta = sCarpeta;
      this.IDActual = id;
      //Me.numagiKnowID.Value
      this.SubCarpeta = sSubCarpeta;
      //Sesion.agiIsNull(.IDActual & " - " &  txtagiKnowTitulo.Text, "")
      if (Accion == EAccion.Insercion && this.CarpetaAdjuntosExisteyTieneFicheros(this))
         bolSeguir = false;
      if (bolSeguir)
         if (!string.IsNullOrEmpty(this.SubCarpeta))
            bolSeguir = this.CargarArchivos();
      //
      //If Me.TipoMantenimiento <> "Insertar" Then 
      if (Accion != EAccion.Insercion)
      {
         DescripcíonFinal = ComprobarDescripcionAdjuntosHaCambiado(SubCarpeta, sSubCarpeta, Carpeta);
         if (DescripcíonFinal != string.Empty)
            EstablecerValorDelControl(ref  p_CtrlContieneDescripcion, DescripcíonFinal);
         // Me.txtagiKnowTitulo.Text = DescripcíonFinal
         this.Enabled = bolActivarControl;
      }
   }
   //'
   /// <summary>
   /// Cambiar nombre de adjuntos?
   /// </summary>
   /// <param name="Accion">Acción mto16 Agenoma</param>
   /// <remarks></remarks>
   public void ActualizarAdjuntos(EAccion Accion)
   {
      int id = DevolverValorDelControl(ref p_CtrlContieneId);
      string txt = DevolverValorDelControl(ref  p_CtrlContieneDescripcion);
      string sSubCarpeta = string.Format("{0} - {1}", id, txt).Trim();
      string sCarpeta = p_strSubCarpetaindicada;
      // "agiKnowCliente"
      //'
      //Actualizar Información ADJUNTOS
      var _with8 = this;
      _with8.Carpeta = sCarpeta;
      //"acciones"
      _with8.IDActual = id;
      // intidaccion.Value
      //Según si es Alta o Modificación cambia el orden pq
      //sino archivosAdjuntosAEliminar de Adjuntos no borra en  las rutas correctas en modificación
      //o NombreSubcarpeta no es correcto en Alta
      // Me.TipoMantenimiento = "Insertar" Then
      if (Accion == EAccion.Insercion)
      {
         _with8.SubCarpeta = sSubCarpeta;
         //NombreSubcarpeta 'drFila.Item("ParteID").ToString
         //Recorrer adjuntos para cambiarle la descripcion  (si cabe pq. si eliminamos un adjunto ya lo comprueba por ej)
         _with8.CambiarNombreAdjunto();
         //.ProcesarAccionesPendientes()... SC: PQ? Fuera
      }
      else
      {
         //.ProcesarAccionesPendientes()... SC: PQ? Fuera
         _with8.SubCarpeta = sSubCarpeta;
         //NombreSubcarpeta
         _with8.CambiarNombreAdjunto();
      }
   }
   //'
   public void GuardarAdjuntosAgenoma(string strNombreSubcarpeta, Configuracion.AGeNomaCore.EAccion AgenomaAccion)
   {
      //Dim NombreSubcarpeta As String = String.Empty

      //Actualizar Información ADJUNTOS
      //Según si es Alta o Modificación cambia el orden pq
      //sino archivosAdjuntosAEliminar de Adjuntos no borra en  las rutas correctas en modificación
      //o NombreSubcarpeta no es correcto en Alta
      switch (AgenomaAccion)
      {
         case Insercion:
            SubCarpeta = strNombreSubcarpeta;
            // drFila("ParteID") & " - " &  txtDescripcion.Text
            //Recorrer adjuntos para cambiarle la  descripcion (si cabe pq. si eliminamos un adjunto ya lo comprueba por ej)
            CambiarNombreAdjunto();
            ProcesarAccionesPendientes();
            break;
         case Modificacion:
            //EAccion.Consulta
            CorregirListaElminacionesAdjuntos();
            //.CorregirListaElminacionesAdjuntos(clsVariables.str_PathAdjuntos & _
            //                                     "\agiKnowCliente\" & _
            //                                     NombreSubcarpeta) 'Solo cuando control adjuntos no se cierra al guardar  (como un panel de agenoma)
            ProcesarAccionesPendientes();
            SubCarpeta = strNombreSubcarpeta;
            CambiarNombreAdjunto();
            break;
      }
   }

   public bool ValidacionAdjuntosAgenoma(Configuracion.AGeNomaCore.EAccion AgenomaAccion)
   {
      //Validaciones adjuntos
      bool Ret = true;

      //With adjArchivos
      switch (AgenomaAccion)
      {
         case Insercion:
            // Insercion
            if (CarpetaAdjuntosExisteyTieneFicheros(this))
               return false;
            break;
         case EAccion.Consulta:
         case Modificacion:
            // Consulta, Modificacion
            //If  MasDeUnIdEnCarpetaAdjuntos(i.agiKnowID, _
            //                                UbicacionRepositorio & "\" & _
            //                               Carpeta &  "\") Then Ret = False : adjArchivos.Focus()
            if (MasDeUnIdEnCarpetaAdjuntos(IDActual, UbicacionRepositorio + "\\" + Carpeta + "\\")) { Ret = false; Focus(); }
            break;
      }
      //End With

      return Ret;
   }

   /// <summary>
   /// Reiniciar/Recargar el control de adjuntos
   /// </summary>
   /// <param name="strIdActual">Ej: 1 - Documentación. Sería el  1</param>
   /// <param name="strDescripcion">Ej: 1 - Documentación. Sería el  Documentación</param>
   /// <param name="strCarpeta">Ej: Seria P:\Gproy\Adjuntos\Partes.  Sería Partes</param>
   /// <param name="Accion">Ej: Acción del Agenoma: Insertar,  Modificar, etc..</param>
   /// <remarks></remarks>
   public void ReiniciarControlAdjuntos(string strIdActual, ref string strDescripcion, string strCarpeta,
                                                                            mtoBase.eTipoAccion TipoAccionPadre)
   {
      return;
      string NuevoNombre = string.Empty;
      bool bolSeguir = true;
      string DescripcionFinal = string.Empty;
      string strSubcarpetaInicial = string.Empty;
      string idActualConDescripcion;
      //
      //Establecer valores
      BorrarColeccionesDeDatos();
      //Reiniciar/Limpieza
      UbicacionRepositorio = clsVariables.str_PathAdjuntos;
      //Entorno.PathAdjuntos
      Carpeta = strCarpeta;
      //"agiKnowCliente"
      IDActual = strIdActual;
      //i.agiKnowID '_intClaveID
      idActualConDescripcion = strIdActual + " - " + strDescripcion.Trim();
      strSubcarpetaInicial = string.IsNullOrEmpty(idActualConDescripcion) ? string.Empty : idActualConDescripcion;
      //agiIsNull(strClaveParteMasDescripcion, "")
      SubCarpeta = strSubcarpetaInicial;

      if (TipoAccionPadre == mtoBase.eTipoAccion.Anyadir && CarpetaAdjuntosExisteyTieneFicheros(this))
         bolSeguir = false;
      if (bolSeguir)
      {
         if (!string.IsNullOrEmpty(SubCarpeta))
            bolSeguir = CargarArchivos();
      }

      if (bolSeguir && (TipoAccionPadre == mtoBase.eTipoAccion.Editar || TipoAccionPadre == mtoBase.eTipoAccion.Consultar))
      {
         //Sincronizar descripciones entre gproy y explorer
         DescripcionFinal = ComprobarDescripcionAdjuntosHaCambiado(SubCarpeta, strSubcarpetaInicial, Carpeta);
         if (DescripcionFinal != string.Empty)
         {
            //RaiseEvent  utmMantenimiento_ToolClick(Nothing, "Editar")  '{Infragistics.Win.UltraWinToolbars.UltraToolbarsManager}
            strDescripcion = DescripcionFinal;
            //i.agiKnowTitulo = DescripcionFinal

            //Windows.Forms.SendKeys.Send("{F11}")  'Editar
            //btnEditar()
         }
      }
      Enabled = false;
   }
   //'
   /// <summary>
   /// VAlidación del control adjuntos para Agenoma
   /// </summary>
   /// <param name="Accion"></param>
   /// <returns></returns>
   /// <remarks></remarks>
   public bool ValidacionAdjuntos(EAccion Accion)
   {
      bool Ret = true;
      try
      {
         //If Me.TipoMantenimiento = "Insertar" Then
         if (Accion == EAccion.Insercion)
         {
            if (CarpetaAdjuntosExisteyTieneFicheros(this))
               Ret = false;
         }
         else
         {
            if (this.MasDeUnIdEnCarpetaAdjuntos(DevolverValorDelControl(ref   p_CtrlContieneId), string.Format("{0}\\{1}\\", UbicacionRepositorio, Carpeta)))
               Ret = false;
         }
         return Ret;
         //
      }
      catch (Exception ex)
      {
         Interaction.MsgBox(ex.Message, MsgBoxStyle.Critical, "Error");
         return false;
      }

   }
   #endregion

}